package util;

import java.util.ArrayList;
import java.util.Vector;
import java.util.concurrent.*;

/**
 * 并发集合 (volatile +读不锁,写锁)
 *
 * COW数组很大 原生的是读写都加锁(vector) 但写非常耗时,并发支持度低
 *  >取消读锁->读写,读读可并发 写单加锁
 *   >>volatile(解决cpu缓存器和主存的不一致问题),使得写完成替换的一瞬间不会让读发生不一致问题 ps:对读不加锁了
 *    PS普通的int number没什么必要,应该服务于大数据结构的读写问题int[]
 *
 * @author yuank
 * @date 2024/12/25 10:00:30
 */
// * 并发下List集合
class List {
    // * 查写全部都是synchronized 某时刻只允许一个线程 读/写oldList
    private Vector<Integer> oldList;

    // * 读操作不加锁 写加锁
    // 支持写时复制且使用volatile解决A线程更新后B读取的还是旧数据(CPU缓存与主存)的读写一致性问题
    private CopyOnWriteArrayList<Integer> newList;

    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        CopyOnWriteArrayList<Integer> newIntegers = new CopyOnWriteArrayList<>();
        //线程并发修改一个资源
        for (int i = 0; i < 15; i++) {
            //int currentIndex = i;
            new Thread( () -> {
                integers.add((int) (Math.random() * 10) + 1);
                //System.out.println("i：" + String.valueOf(currentIndex));
                System.out.println(integers);
            }, String.valueOf(i)).start();
        }

        //线程并发修改一个资源
        for (int i = 0; i < 10; i++) {
            final int now = i; // 一人一个 + 不允许嵌套
            new Thread( () -> {
                newIntegers.add((int) (Math.random() * 10) + 1);
                System.out.println(now);
            }, String.valueOf(i)).start();
        }
    }
}
// * 并发下Set集合 与上面原理一致

// * 并发下Map集合 ConcurrentHashMap(分段锁) HashTable(Vector)

class queue {
    private BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(1);
    private SynchronousQueue<Integer> synchronousQueue = new SynchronousQueue<>();
}


